package com.dragon.modules.yuegou.query.product;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.product.SpuEntity;
import com.dragon.modules.yuegou.enums.OwnerType;
import com.dragon.modules.yuegou.enums.SkuType;
import com.dragon.modules.yuegou.enums.product.SpuPackageType;
import com.dragon.modules.yuegou.enums.product.SpuPublishStatus;
import com.dragon.modules.yuegou.enums.product.SpuShowModule;
import com.dragon.modules.yuegou.enums.product.SpuTemplateType;
import com.dragon.modules.yuegou.enums.product.SpuTimeLimitType;
import com.dragon.modules.yuegou.enums.product.SpuVerifyStatus;
import com.dragon.modules.yuegou.enums.product.SpuViewModel;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 商品信息 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2023-09-08 08:40:09
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class SpuQuery extends SpuEntity implements Query<SpuEntity> {

    /** ID查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** 集团ID查询条件 */
	@JsonUnwrapped(prefix = "groupId")
	private Condition<String> groupIdCondition;

    /** [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件 */
	@JsonUnwrapped(prefix = "ownerType")
	private Condition<OwnerType> ownerTypeCondition;

    /** [全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件 */
	@JsonUnwrapped(prefix = "skuType")
	private Condition<SkuType> skuTypeCondition;

    /** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 商品类目ID查询条件 */
	@JsonUnwrapped(prefix = "categoryId")
	private Condition<String> categoryIdCondition;

    /** 商家ID查询条件 */
	@JsonUnwrapped(prefix = "merchantId")
	private Condition<String> merchantIdCondition;

    /** 商品名称/标题查询条件 */
	@JsonUnwrapped(prefix = "title")
	private Condition<String> titleCondition;

    /** [枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件 */
	@JsonUnwrapped(prefix = "showModule")
	private Condition<SpuShowModule> showModuleCondition;

    /** 显示按钮名称查询条件 */
	@JsonUnwrapped(prefix = "showBtnTitle")
	private Condition<String> showBtnTitleCondition;

    /** 库存量查询条件 */
	@JsonUnwrapped(prefix = "stock")
	private Condition<Integer> stockCondition;

    /** 产品主图查询条件 */
	@JsonUnwrapped(prefix = "mainImg")
	private Condition<String> mainImgCondition;

    /** 图片列表查询条件 */
	@JsonUnwrapped(prefix = "imgs")
	private Condition<String> imgsCondition;

    /** 商品最高价查询条件 */
	@JsonUnwrapped(prefix = "maxPrice")
	private Condition<BigDecimal> maxPriceCondition;

    /** 商品最低价查询条件 */
	@JsonUnwrapped(prefix = "minPrice")
	private Condition<BigDecimal> minPriceCondition;

    /** 单价查询条件 */
	@JsonUnwrapped(prefix = "price")
	private Condition<BigDecimal> priceCondition;

    /** 积分查询条件 */
	@JsonUnwrapped(prefix = "point")
	private Condition<Integer> pointCondition;

    /** 每人最大购买数量查询条件 */
	@JsonUnwrapped(prefix = "maxBuyNum")
	private Condition<Integer> maxBuyNumCondition;

    /** 积分商品 最低购买等级 0为不限制查询条件 */
	@JsonUnwrapped(prefix = "minBuyLevel")
	private Condition<Integer> minBuyLevelCondition;

    /** 市场价查询条件 */
	@JsonUnwrapped(prefix = "marketPrice")
	private Condition<BigDecimal> marketPriceCondition;

    /** 品牌查询条件 */
	@JsonUnwrapped(prefix = "brand")
	private Condition<String> brandCondition;

    /** 模板ID查询条件 */
	@JsonUnwrapped(prefix = "templateId")
	private Condition<String> templateIdCondition;

    /** [枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件 */
	@JsonUnwrapped(prefix = "templateType")
	private Condition<SpuTemplateType> templateTypeCondition;

    /** [枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件 */
	@JsonUnwrapped(prefix = "publishStatus")
	private Condition<SpuPublishStatus> publishStatusCondition;

    /** [枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件 */
	@JsonUnwrapped(prefix = "verifyStatus")
	private Condition<SpuVerifyStatus> verifyStatusCondition;

    /** [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件 */
	@JsonUnwrapped(prefix = "timeLimitType")
	private Condition<SpuTimeLimitType> timeLimitTypeCondition;

    /** 失效天数（获取后能够有效的天数）查询条件 */
	@JsonUnwrapped(prefix = "validDays")
	private Condition<Integer> validDaysCondition;

    /** [枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件 */
	@JsonUnwrapped(prefix = "viewModel")
	private Condition<SpuViewModel> viewModelCondition;

    /** 展示 有效期 开始时间查询条件 */
	@JsonUnwrapped(prefix = "viewBeginTime")
	private Condition<LocalDateTime> viewBeginTimeCondition;

    /** 展示 有效期 结束时间查询条件 */
	@JsonUnwrapped(prefix = "viewEndTime")
	private Condition<LocalDateTime> viewEndTimeCondition;

    /** 购买开始时间查询条件 */
	@JsonUnwrapped(prefix = "buyBeginTime")
	private Condition<LocalDateTime> buyBeginTimeCondition;

    /** 购买结束时间查询条件 */
	@JsonUnwrapped(prefix = "buyEndTime")
	private Condition<LocalDateTime> buyEndTimeCondition;

    /** 有效期 开始时间查询条件 */
	@JsonUnwrapped(prefix = "beginTime")
	private Condition<LocalDateTime> beginTimeCondition;

    /** 有效期 结束时间查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDateTime> endTimeCondition;

    /** 商品描述 图片列表查询条件 */
	@JsonUnwrapped(prefix = "description")
	private Condition<String> descriptionCondition;

    /** 商品图片描述 图片列表查询条件 */
	@JsonUnwrapped(prefix = "imgDescription")
	private Condition<String> imgDescriptionCondition;

    /** [枚举]是否套餐：0-否-NO、1-是-YES查询条件 */
	@JsonUnwrapped(prefix = "packageType")
	private Condition<SpuPackageType> packageTypeCondition;

    /** 浏览量查询条件 */
	@JsonUnwrapped(prefix = "scanNum")
	private Condition<Integer> scanNumCondition;

    /** 使用规则查询条件 */
	@JsonUnwrapped(prefix = "useRule")
	private Condition<String> useRuleCondition;

    /** 创建人ID查询条件 */
	@JsonUnwrapped(prefix = "createdBy")
	private Condition<String> createdByCondition;

    /** 创建时间查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

    /** 更新人ID查询条件 */
	@JsonUnwrapped(prefix = "modifiedBy")
	private Condition<String> modifiedByCondition;

    /** 更新时间查询条件 */
	@JsonUnwrapped(prefix = "modifiedTime")
	private Condition<LocalDateTime> modifiedTimeCondition;

    /** 审批人查询条件 */
	@JsonUnwrapped(prefix = "checkBy")
	private Condition<String> checkByCondition;

    /** 审批时间查询条件 */
	@JsonUnwrapped(prefix = "checkTime")
	private Condition<LocalDateTime> checkTimeCondition;

    /** 审批意见查询条件 */
	@JsonUnwrapped(prefix = "checkRemark")
	private Condition<String> checkRemarkCondition;

    /** 逻辑删除，1表示已删除,0表示未删除查询条件 */
	@JsonUnwrapped(prefix = "del")
	private Condition<Boolean> delCondition;

    /** 删除人ID查询条件 */
	@JsonUnwrapped(prefix = "delBy")
	private Condition<String> delByCondition;

    /** 删除时间查询条件 */
	@JsonUnwrapped(prefix = "delTime")
	private Condition<LocalDateTime> delTimeCondition;

    /** 排序查询条件 */
	@JsonUnwrapped(prefix = "sortNo")
	private Condition<Integer> sortNoCondition;

    /** 售卖开始时间查询条件 */
	@JsonUnwrapped(prefix = "sellBeginTime")
	private Condition<LocalDateTime> sellBeginTimeCondition;

    /** 售卖结束时间查询条件 */
	@JsonUnwrapped(prefix = "sellEndTime")
	private Condition<LocalDateTime> sellEndTimeCondition;

    /** 倒计时开始时间查询条件 */
	@JsonUnwrapped(prefix = "invertedBeginTime")
	private Condition<LocalDateTime> invertedBeginTimeCondition;

    /** 倒计时结束时间查询条件 */
	@JsonUnwrapped(prefix = "invertedEndTime")
	private Condition<LocalDateTime> invertedEndTimeCondition;

    /** [枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件 */
	@JsonUnwrapped(prefix = "invertedShow")
	private Condition<Integer> invertedShowCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public SpuQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public SpuQuery(SpuEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public SpuQuery(SpuQuery other) {
		super(other);
		if(other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if(other.groupIdCondition != null) {
			this.groupIdCondition = other.groupIdCondition.copy();
		}
		if(other.ownerTypeCondition != null) {
			this.ownerTypeCondition = other.ownerTypeCondition.copy();
		}
		if(other.skuTypeCondition != null) {
			this.skuTypeCondition = other.skuTypeCondition.copy();
		}
		if(other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if(other.categoryIdCondition != null) {
			this.categoryIdCondition = other.categoryIdCondition.copy();
		}
		if(other.merchantIdCondition != null) {
			this.merchantIdCondition = other.merchantIdCondition.copy();
		}
		if(other.titleCondition != null) {
			this.titleCondition = other.titleCondition.copy();
		}
		if(other.showModuleCondition != null) {
			this.showModuleCondition = other.showModuleCondition.copy();
		}
		if(other.showBtnTitleCondition != null) {
			this.showBtnTitleCondition = other.showBtnTitleCondition.copy();
		}
		if(other.stockCondition != null) {
			this.stockCondition = other.stockCondition.copy();
		}
		if(other.mainImgCondition != null) {
			this.mainImgCondition = other.mainImgCondition.copy();
		}
		if(other.imgsCondition != null) {
			this.imgsCondition = other.imgsCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(SpuQuery other) {
		if (other.maxPriceCondition != null) {
			this.maxPriceCondition = other.maxPriceCondition.copy();
		}
		if (other.minPriceCondition != null) {
			this.minPriceCondition = other.minPriceCondition.copy();
		}
		if (other.priceCondition != null) {
			this.priceCondition = other.priceCondition.copy();
		}
		if (other.pointCondition != null) {
			this.pointCondition = other.pointCondition.copy();
		}
		if (other.maxBuyNumCondition != null) {
			this.maxBuyNumCondition = other.maxBuyNumCondition.copy();
		}
		if (other.minBuyLevelCondition != null) {
			this.minBuyLevelCondition = other.minBuyLevelCondition.copy();
		}
		if (other.marketPriceCondition != null) {
			this.marketPriceCondition = other.marketPriceCondition.copy();
		}
		if (other.brandCondition != null) {
			this.brandCondition = other.brandCondition.copy();
		}
		if (other.templateIdCondition != null) {
			this.templateIdCondition = other.templateIdCondition.copy();
		}
		if (other.templateTypeCondition != null) {
			this.templateTypeCondition = other.templateTypeCondition.copy();
		}
		if (other.publishStatusCondition != null) {
			this.publishStatusCondition = other.publishStatusCondition.copy();
		}
		if (other.verifyStatusCondition != null) {
			this.verifyStatusCondition = other.verifyStatusCondition.copy();
		}
		if (other.timeLimitTypeCondition != null) {
			this.timeLimitTypeCondition = other.timeLimitTypeCondition.copy();
		}
		if (other.validDaysCondition != null) {
			this.validDaysCondition = other.validDaysCondition.copy();
		}
		this.setOther2(other);
	}

	private void setOther2(SpuQuery other) {
		if (other.viewModelCondition != null) {
			this.viewModelCondition = other.viewModelCondition.copy();
		}
		if (other.viewBeginTimeCondition != null) {
			this.viewBeginTimeCondition = other.viewBeginTimeCondition.copy();
		}
		if (other.viewEndTimeCondition != null) {
			this.viewEndTimeCondition = other.viewEndTimeCondition.copy();
		}
		if (other.buyBeginTimeCondition != null) {
			this.buyBeginTimeCondition = other.buyBeginTimeCondition.copy();
		}
		if (other.buyEndTimeCondition != null) {
			this.buyEndTimeCondition = other.buyEndTimeCondition.copy();
		}
		if (other.beginTimeCondition != null) {
			this.beginTimeCondition = other.beginTimeCondition.copy();
		}
		if (other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if (other.descriptionCondition != null) {
			this.descriptionCondition = other.descriptionCondition.copy();
		}
		if (other.imgDescriptionCondition != null) {
			this.imgDescriptionCondition = other.imgDescriptionCondition.copy();
		}
		if (other.packageTypeCondition != null) {
			this.packageTypeCondition = other.packageTypeCondition.copy();
		}
		if (other.scanNumCondition != null) {
			this.scanNumCondition = other.scanNumCondition.copy();
		}
		if (other.useRuleCondition != null) {
			this.useRuleCondition = other.useRuleCondition.copy();
		}
		if (other.createdByCondition != null) {
			this.createdByCondition = other.createdByCondition.copy();
		}
		if (other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		this.setOther3(other);
	}
	private void setOther3(SpuQuery other){
		if(other.modifiedByCondition != null) {
			this.modifiedByCondition = other.modifiedByCondition.copy();
		}
		if(other.modifiedTimeCondition != null) {
			this.modifiedTimeCondition = other.modifiedTimeCondition.copy();
		}
		if(other.checkByCondition != null) {
			this.checkByCondition = other.checkByCondition.copy();
		}
		if(other.checkTimeCondition != null) {
			this.checkTimeCondition = other.checkTimeCondition.copy();
		}
		if(other.checkRemarkCondition != null) {
			this.checkRemarkCondition = other.checkRemarkCondition.copy();
		}
		if(other.delCondition != null) {
			this.delCondition = other.delCondition.copy();
		}
		if(other.delByCondition != null) {
			this.delByCondition = other.delByCondition.copy();
		}
		if(other.delTimeCondition != null) {
			this.delTimeCondition = other.delTimeCondition.copy();
		}
		if(other.sortNoCondition != null) {
			this.sortNoCondition = other.sortNoCondition.copy();
		}
		if(other.sellBeginTimeCondition != null) {
			this.sellBeginTimeCondition = other.sellBeginTimeCondition.copy();
		}
		if(other.sellEndTimeCondition != null) {
			this.sellEndTimeCondition = other.sellEndTimeCondition.copy();
		}
		if(other.invertedBeginTimeCondition != null) {
			this.invertedBeginTimeCondition = other.invertedBeginTimeCondition.copy();
		}
		if(other.invertedEndTimeCondition != null) {
			this.invertedEndTimeCondition = other.invertedEndTimeCondition.copy();
		}
		if(other.invertedShowCondition != null) {
			this.invertedShowCondition = other.invertedShowCondition.copy();
		}
	}

	@Override
	public QueryWrapper<SpuEntity> toQueryWrapper() {
		QueryWrapper<SpuEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (groupIdCondition != null) {
			groupIdCondition.toWrapper(wrapper, COL_GROUP_ID);
		}
		if (ownerTypeCondition != null) {
			ownerTypeCondition.toWrapper(wrapper, COL_OWNER_TYPE);
		}
		if (skuTypeCondition != null) {
			skuTypeCondition.toWrapper(wrapper, COL_SKU_TYPE);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (categoryIdCondition != null) {
			categoryIdCondition.toWrapper(wrapper, COL_CATEGORY_ID);
		}
		if (merchantIdCondition != null) {
			merchantIdCondition.toWrapper(wrapper, COL_MERCHANT_ID);
		}
		if (titleCondition != null) {
			titleCondition.toWrapper(wrapper, COL_TITLE);
		}
		if (showModuleCondition != null) {
			showModuleCondition.toWrapper(wrapper, COL_SHOW_MODULE);
		}
		if (showBtnTitleCondition != null) {
			showBtnTitleCondition.toWrapper(wrapper, COL_SHOW_BTN_TITLE);
		}
		if (stockCondition != null) {
			stockCondition.toWrapper(wrapper, COL_STOCK);
		}
		if (mainImgCondition != null) {
			mainImgCondition.toWrapper(wrapper, COL_MAIN_IMG);
		}
		if (imgsCondition != null) {
			imgsCondition.toWrapper(wrapper, COL_IMGS);
		}
		return getQueryWrapper(wrapper);
	}

	private QueryWrapper<SpuEntity> getQueryWrapper(QueryWrapper<SpuEntity> wrapper){
		if (maxPriceCondition != null) {
			maxPriceCondition.toWrapper(wrapper, COL_MAX_PRICE);
		}
		if (minPriceCondition != null) {
			minPriceCondition.toWrapper(wrapper, COL_MIN_PRICE);
		}
		if (priceCondition != null) {
			priceCondition.toWrapper(wrapper, COL_PRICE);
		}
		if (pointCondition != null) {
			pointCondition.toWrapper(wrapper, COL_POINT);
		}
		if (maxBuyNumCondition != null) {
			maxBuyNumCondition.toWrapper(wrapper, COL_MAX_BUY_NUM);
		}
		if (minBuyLevelCondition != null) {
			minBuyLevelCondition.toWrapper(wrapper, COL_MIN_BUY_LEVEL);
		}
		if (marketPriceCondition != null) {
			marketPriceCondition.toWrapper(wrapper, COL_MARKET_PRICE);
		}
		if (brandCondition != null) {
			brandCondition.toWrapper(wrapper, COL_BRAND);
		}
		if (templateIdCondition != null) {
			templateIdCondition.toWrapper(wrapper, COL_TEMPLATE_ID);
		}
		if (templateTypeCondition != null) {
			templateTypeCondition.toWrapper(wrapper, COL_TEMPLATE_TYPE);
		}
		if (publishStatusCondition != null) {
			publishStatusCondition.toWrapper(wrapper, COL_PUBLISH_STATUS);
		}
		if (verifyStatusCondition != null) {
			verifyStatusCondition.toWrapper(wrapper, COL_VERIFY_STATUS);
		}
		if (timeLimitTypeCondition != null) {
			timeLimitTypeCondition.toWrapper(wrapper, COL_TIME_LIMIT_TYPE);
		}
		if (validDaysCondition != null) {
			validDaysCondition.toWrapper(wrapper, COL_VALID_DAYS);
		}
		return getQueryWrapper2(wrapper);
	}

	private QueryWrapper<SpuEntity> getQueryWrapper2(QueryWrapper<SpuEntity> wrapper){
		if (viewModelCondition != null) {
			viewModelCondition.toWrapper(wrapper, COL_VIEW_MODEL);
		}
		if (viewBeginTimeCondition != null) {
			viewBeginTimeCondition.toWrapper(wrapper, COL_VIEW_BEGIN_TIME);
		}
		if (viewEndTimeCondition != null) {
			viewEndTimeCondition.toWrapper(wrapper, COL_VIEW_END_TIME);
		}
		if (buyBeginTimeCondition != null) {
			buyBeginTimeCondition.toWrapper(wrapper, COL_BUY_BEGIN_TIME);
		}
		if (buyEndTimeCondition != null) {
			buyEndTimeCondition.toWrapper(wrapper, COL_BUY_END_TIME);
		}
		if (beginTimeCondition != null) {
			beginTimeCondition.toWrapper(wrapper, COL_BEGIN_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (descriptionCondition != null) {
			descriptionCondition.toWrapper(wrapper, COL_DESCRIPTION);
		}
		if (imgDescriptionCondition != null) {
			imgDescriptionCondition.toWrapper(wrapper, COL_IMG_DESCRIPTION);
		}
		if (packageTypeCondition != null) {
			packageTypeCondition.toWrapper(wrapper, COL_PACKAGE_TYPE);
		}
		if (scanNumCondition != null) {
			scanNumCondition.toWrapper(wrapper, COL_SCAN_NUM);
		}
		if (useRuleCondition != null) {
			useRuleCondition.toWrapper(wrapper, COL_USE_RULE);
		}
		if (createdByCondition != null) {
			createdByCondition.toWrapper(wrapper, COL_CREATED_BY);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		return getQueryWrapper3(wrapper);
	}

	private QueryWrapper<SpuEntity> getQueryWrapper3(QueryWrapper<SpuEntity> wrapper){
		if (modifiedByCondition != null) {
			modifiedByCondition.toWrapper(wrapper, COL_MODIFIED_BY);
		}
		if (modifiedTimeCondition != null) {
			modifiedTimeCondition.toWrapper(wrapper, COL_MODIFIED_TIME);
		}
		if (checkByCondition != null) {
			checkByCondition.toWrapper(wrapper, COL_CHECK_BY);
		}
		if (checkTimeCondition != null) {
			checkTimeCondition.toWrapper(wrapper, COL_CHECK_TIME);
		}
		if (checkRemarkCondition != null) {
			checkRemarkCondition.toWrapper(wrapper, COL_CHECK_REMARK);
		}
		if (delCondition != null) {
			delCondition.toWrapper(wrapper, COL_DEL);
		}
		if (delByCondition != null) {
			delByCondition.toWrapper(wrapper, COL_DEL_BY);
		}
		if (delTimeCondition != null) {
			delTimeCondition.toWrapper(wrapper, COL_DEL_TIME);
		}
		if (sortNoCondition != null) {
			sortNoCondition.toWrapper(wrapper, COL_SORT_NO);
		}
		if (sellBeginTimeCondition != null) {
			sellBeginTimeCondition.toWrapper(wrapper, COL_SELL_BEGIN_TIME);
		}
		if (sellEndTimeCondition != null) {
			sellEndTimeCondition.toWrapper(wrapper, COL_SELL_END_TIME);
		}
		if (invertedBeginTimeCondition != null) {
			invertedBeginTimeCondition.toWrapper(wrapper, COL_INVERTED_BEGIN_TIME);
		}
		if (invertedEndTimeCondition != null) {
			invertedEndTimeCondition.toWrapper(wrapper, COL_INVERTED_END_TIME);
		}
		if (invertedShowCondition != null) {
			invertedShowCondition.toWrapper(wrapper, COL_INVERTED_SHOW);
		}
		return wrapper;
	}

	/**
	 * 构造并返回ID查询条件
	 * 
	 * @return idCondition ID查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取ID查询条件
	 * 
	 * @return idCondition ID查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置ID查询条件
	 * 
	 * @param idCondition ID查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> groupId() {
		this.groupIdCondition = new Condition<>();
		return this.groupIdCondition;
	}
	
	/**
	 * 获取集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> getGroupIdCondition() {
		return groupIdCondition;
	}

	/**
	 * 设置集团ID查询条件
	 * 
	 * @param groupIdCondition 集团ID查询条件
	 */
	public void setGroupIdCondition(Condition<String> groupIdCondition) {
		this.groupIdCondition = groupIdCondition;
	}

	/**
	 * 构造并返回[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<OwnerType> ownerType() {
		this.ownerTypeCondition = new Condition<>();
		return this.ownerTypeCondition;
	}
	
	/**
	 * 获取[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<OwnerType> getOwnerTypeCondition() {
		return ownerTypeCondition;
	}

	/**
	 * 设置[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @param ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public void setOwnerTypeCondition(Condition<OwnerType> ownerTypeCondition) {
		this.ownerTypeCondition = ownerTypeCondition;
	}

	/**
	 * 构造并返回[全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 * 
	 * @return skuTypeCondition [全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 */
	public Condition<SkuType> skuType() {
		this.skuTypeCondition = new Condition<>();
		return this.skuTypeCondition;
	}
	
	/**
	 * 获取[全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 * 
	 * @return skuTypeCondition [全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 */
	public Condition<SkuType> getSkuTypeCondition() {
		return skuTypeCondition;
	}

	/**
	 * 设置[全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 * 
	 * @param skuTypeCondition [全局枚举]商品类型：0-悦卡-YUECARD、1-套餐-PACKAGE、2-商户停车券-PARKCOUPON、3-积分停车券-POINTPARKCOUPON、4-实物-GOODS、5-积分商品-POINTGOODS、6-伪造商品-MOCK、7-奖品-PRIZE、8-优惠券-DISCOUNTCOUPON、9-礼包-GIFTBAG、10-免费商品/卷-FREE查询条件
	 */
	public void setSkuTypeCondition(Condition<SkuType> skuTypeCondition) {
		this.skuTypeCondition = skuTypeCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 * 
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回商品类目ID查询条件
	 * 
	 * @return categoryIdCondition 商品类目ID查询条件
	 */
	public Condition<String> categoryId() {
		this.categoryIdCondition = new Condition<>();
		return this.categoryIdCondition;
	}
	
	/**
	 * 获取商品类目ID查询条件
	 * 
	 * @return categoryIdCondition 商品类目ID查询条件
	 */
	public Condition<String> getCategoryIdCondition() {
		return categoryIdCondition;
	}

	/**
	 * 设置商品类目ID查询条件
	 * 
	 * @param categoryIdCondition 商品类目ID查询条件
	 */
	public void setCategoryIdCondition(Condition<String> categoryIdCondition) {
		this.categoryIdCondition = categoryIdCondition;
	}

	/**
	 * 构造并返回商家ID查询条件
	 * 
	 * @return merchantIdCondition 商家ID查询条件
	 */
	public Condition<String> merchantId() {
		this.merchantIdCondition = new Condition<>();
		return this.merchantIdCondition;
	}
	
	/**
	 * 获取商家ID查询条件
	 * 
	 * @return merchantIdCondition 商家ID查询条件
	 */
	public Condition<String> getMerchantIdCondition() {
		return merchantIdCondition;
	}

	/**
	 * 设置商家ID查询条件
	 * 
	 * @param merchantIdCondition 商家ID查询条件
	 */
	public void setMerchantIdCondition(Condition<String> merchantIdCondition) {
		this.merchantIdCondition = merchantIdCondition;
	}

	/**
	 * 构造并返回商品名称/标题查询条件
	 * 
	 * @return titleCondition 商品名称/标题查询条件
	 */
	public Condition<String> title() {
		this.titleCondition = new Condition<>();
		return this.titleCondition;
	}
	
	/**
	 * 获取商品名称/标题查询条件
	 * 
	 * @return titleCondition 商品名称/标题查询条件
	 */
	public Condition<String> getTitleCondition() {
		return titleCondition;
	}

	/**
	 * 设置商品名称/标题查询条件
	 * 
	 * @param titleCondition 商品名称/标题查询条件
	 */
	public void setTitleCondition(Condition<String> titleCondition) {
		this.titleCondition = titleCondition;
	}

	/**
	 * 构造并返回[枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 * 
	 * @return showModuleCondition [枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 */
	public Condition<SpuShowModule> showModule() {
		this.showModuleCondition = new Condition<>();
		return this.showModuleCondition;
	}
	
	/**
	 * 获取[枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 * 
	 * @return showModuleCondition [枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 */
	public Condition<SpuShowModule> getShowModuleCondition() {
		return showModuleCondition;
	}

	/**
	 * 设置[枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 * 
	 * @param showModuleCondition [枚举]展示模块：0-优选好货-GOODS、1-积分商城-SHOP、2-套餐-PACKAGE、3-商户停车券-MERCHANT、4-限时折扣-LIMITSALES、5-秒杀-SECKILL、6-拼团-COLLAGE、7-助力砍价-HELP、10-套餐子商品-PACKAGE_ITEM、11-奖品-PRIZE、12-到家商品-GOHOME、13-不显示-NOSHOW查询条件
	 */
	public void setShowModuleCondition(Condition<SpuShowModule> showModuleCondition) {
		this.showModuleCondition = showModuleCondition;
	}

	/**
	 * 构造并返回显示按钮名称查询条件
	 * 
	 * @return showBtnTitleCondition 显示按钮名称查询条件
	 */
	public Condition<String> showBtnTitle() {
		this.showBtnTitleCondition = new Condition<>();
		return this.showBtnTitleCondition;
	}
	
	/**
	 * 获取显示按钮名称查询条件
	 * 
	 * @return showBtnTitleCondition 显示按钮名称查询条件
	 */
	public Condition<String> getShowBtnTitleCondition() {
		return showBtnTitleCondition;
	}

	/**
	 * 设置显示按钮名称查询条件
	 * 
	 * @param showBtnTitleCondition 显示按钮名称查询条件
	 */
	public void setShowBtnTitleCondition(Condition<String> showBtnTitleCondition) {
		this.showBtnTitleCondition = showBtnTitleCondition;
	}

	/**
	 * 构造并返回库存量查询条件
	 * 
	 * @return stockCondition 库存量查询条件
	 */
	public Condition<Integer> stock() {
		this.stockCondition = new Condition<>();
		return this.stockCondition;
	}
	
	/**
	 * 获取库存量查询条件
	 * 
	 * @return stockCondition 库存量查询条件
	 */
	public Condition<Integer> getStockCondition() {
		return stockCondition;
	}

	/**
	 * 设置库存量查询条件
	 * 
	 * @param stockCondition 库存量查询条件
	 */
	public void setStockCondition(Condition<Integer> stockCondition) {
		this.stockCondition = stockCondition;
	}

	/**
	 * 构造并返回产品主图查询条件
	 * 
	 * @return mainImgCondition 产品主图查询条件
	 */
	public Condition<String> mainImg() {
		this.mainImgCondition = new Condition<>();
		return this.mainImgCondition;
	}
	
	/**
	 * 获取产品主图查询条件
	 * 
	 * @return mainImgCondition 产品主图查询条件
	 */
	public Condition<String> getMainImgCondition() {
		return mainImgCondition;
	}

	/**
	 * 设置产品主图查询条件
	 * 
	 * @param mainImgCondition 产品主图查询条件
	 */
	public void setMainImgCondition(Condition<String> mainImgCondition) {
		this.mainImgCondition = mainImgCondition;
	}

	/**
	 * 构造并返回图片列表查询条件
	 * 
	 * @return imgsCondition 图片列表查询条件
	 */
	public Condition<String> imgs() {
		this.imgsCondition = new Condition<>();
		return this.imgsCondition;
	}
	
	/**
	 * 获取图片列表查询条件
	 * 
	 * @return imgsCondition 图片列表查询条件
	 */
	public Condition<String> getImgsCondition() {
		return imgsCondition;
	}

	/**
	 * 设置图片列表查询条件
	 * 
	 * @param imgsCondition 图片列表查询条件
	 */
	public void setImgsCondition(Condition<String> imgsCondition) {
		this.imgsCondition = imgsCondition;
	}

	/**
	 * 构造并返回商品最高价查询条件
	 * 
	 * @return maxPriceCondition 商品最高价查询条件
	 */
	public Condition<BigDecimal> maxPrice() {
		this.maxPriceCondition = new Condition<>();
		return this.maxPriceCondition;
	}
	
	/**
	 * 获取商品最高价查询条件
	 * 
	 * @return maxPriceCondition 商品最高价查询条件
	 */
	public Condition<BigDecimal> getMaxPriceCondition() {
		return maxPriceCondition;
	}

	/**
	 * 设置商品最高价查询条件
	 * 
	 * @param maxPriceCondition 商品最高价查询条件
	 */
	public void setMaxPriceCondition(Condition<BigDecimal> maxPriceCondition) {
		this.maxPriceCondition = maxPriceCondition;
	}

	/**
	 * 构造并返回商品最低价查询条件
	 * 
	 * @return minPriceCondition 商品最低价查询条件
	 */
	public Condition<BigDecimal> minPrice() {
		this.minPriceCondition = new Condition<>();
		return this.minPriceCondition;
	}
	
	/**
	 * 获取商品最低价查询条件
	 * 
	 * @return minPriceCondition 商品最低价查询条件
	 */
	public Condition<BigDecimal> getMinPriceCondition() {
		return minPriceCondition;
	}

	/**
	 * 设置商品最低价查询条件
	 * 
	 * @param minPriceCondition 商品最低价查询条件
	 */
	public void setMinPriceCondition(Condition<BigDecimal> minPriceCondition) {
		this.minPriceCondition = minPriceCondition;
	}

	/**
	 * 构造并返回单价查询条件
	 * 
	 * @return priceCondition 单价查询条件
	 */
	public Condition<BigDecimal> price() {
		this.priceCondition = new Condition<>();
		return this.priceCondition;
	}
	
	/**
	 * 获取单价查询条件
	 * 
	 * @return priceCondition 单价查询条件
	 */
	public Condition<BigDecimal> getPriceCondition() {
		return priceCondition;
	}

	/**
	 * 设置单价查询条件
	 * 
	 * @param priceCondition 单价查询条件
	 */
	public void setPriceCondition(Condition<BigDecimal> priceCondition) {
		this.priceCondition = priceCondition;
	}

	/**
	 * 构造并返回积分查询条件
	 * 
	 * @return pointCondition 积分查询条件
	 */
	public Condition<Integer> point() {
		this.pointCondition = new Condition<>();
		return this.pointCondition;
	}
	
	/**
	 * 获取积分查询条件
	 * 
	 * @return pointCondition 积分查询条件
	 */
	public Condition<Integer> getPointCondition() {
		return pointCondition;
	}

	/**
	 * 设置积分查询条件
	 * 
	 * @param pointCondition 积分查询条件
	 */
	public void setPointCondition(Condition<Integer> pointCondition) {
		this.pointCondition = pointCondition;
	}

	/**
	 * 构造并返回每人最大购买数量查询条件
	 * 
	 * @return maxBuyNumCondition 每人最大购买数量查询条件
	 */
	public Condition<Integer> maxBuyNum() {
		this.maxBuyNumCondition = new Condition<>();
		return this.maxBuyNumCondition;
	}
	
	/**
	 * 获取每人最大购买数量查询条件
	 * 
	 * @return maxBuyNumCondition 每人最大购买数量查询条件
	 */
	public Condition<Integer> getMaxBuyNumCondition() {
		return maxBuyNumCondition;
	}

	/**
	 * 设置每人最大购买数量查询条件
	 * 
	 * @param maxBuyNumCondition 每人最大购买数量查询条件
	 */
	public void setMaxBuyNumCondition(Condition<Integer> maxBuyNumCondition) {
		this.maxBuyNumCondition = maxBuyNumCondition;
	}

	/**
	 * 构造并返回积分商品 最低购买等级 0为不限制查询条件
	 * 
	 * @return minBuyLevelCondition 积分商品 最低购买等级 0为不限制查询条件
	 */
	public Condition<Integer> minBuyLevel() {
		this.minBuyLevelCondition = new Condition<>();
		return this.minBuyLevelCondition;
	}
	
	/**
	 * 获取积分商品 最低购买等级 0为不限制查询条件
	 * 
	 * @return minBuyLevelCondition 积分商品 最低购买等级 0为不限制查询条件
	 */
	public Condition<Integer> getMinBuyLevelCondition() {
		return minBuyLevelCondition;
	}

	/**
	 * 设置积分商品 最低购买等级 0为不限制查询条件
	 * 
	 * @param minBuyLevelCondition 积分商品 最低购买等级 0为不限制查询条件
	 */
	public void setMinBuyLevelCondition(Condition<Integer> minBuyLevelCondition) {
		this.minBuyLevelCondition = minBuyLevelCondition;
	}

	/**
	 * 构造并返回市场价查询条件
	 * 
	 * @return marketPriceCondition 市场价查询条件
	 */
	public Condition<BigDecimal> marketPrice() {
		this.marketPriceCondition = new Condition<>();
		return this.marketPriceCondition;
	}
	
	/**
	 * 获取市场价查询条件
	 * 
	 * @return marketPriceCondition 市场价查询条件
	 */
	public Condition<BigDecimal> getMarketPriceCondition() {
		return marketPriceCondition;
	}

	/**
	 * 设置市场价查询条件
	 * 
	 * @param marketPriceCondition 市场价查询条件
	 */
	public void setMarketPriceCondition(Condition<BigDecimal> marketPriceCondition) {
		this.marketPriceCondition = marketPriceCondition;
	}

	/**
	 * 构造并返回品牌查询条件
	 * 
	 * @return brandCondition 品牌查询条件
	 */
	public Condition<String> brand() {
		this.brandCondition = new Condition<>();
		return this.brandCondition;
	}
	
	/**
	 * 获取品牌查询条件
	 * 
	 * @return brandCondition 品牌查询条件
	 */
	public Condition<String> getBrandCondition() {
		return brandCondition;
	}

	/**
	 * 设置品牌查询条件
	 * 
	 * @param brandCondition 品牌查询条件
	 */
	public void setBrandCondition(Condition<String> brandCondition) {
		this.brandCondition = brandCondition;
	}

	/**
	 * 构造并返回模板ID查询条件
	 * 
	 * @return templateIdCondition 模板ID查询条件
	 */
	public Condition<String> templateId() {
		this.templateIdCondition = new Condition<>();
		return this.templateIdCondition;
	}
	
	/**
	 * 获取模板ID查询条件
	 * 
	 * @return templateIdCondition 模板ID查询条件
	 */
	public Condition<String> getTemplateIdCondition() {
		return templateIdCondition;
	}

	/**
	 * 设置模板ID查询条件
	 * 
	 * @param templateIdCondition 模板ID查询条件
	 */
	public void setTemplateIdCondition(Condition<String> templateIdCondition) {
		this.templateIdCondition = templateIdCondition;
	}

	/**
	 * 构造并返回[枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 * 
	 * @return templateTypeCondition [枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 */
	public Condition<SpuTemplateType> templateType() {
		this.templateTypeCondition = new Condition<>();
		return this.templateTypeCondition;
	}
	
	/**
	 * 获取[枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 * 
	 * @return templateTypeCondition [枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 */
	public Condition<SpuTemplateType> getTemplateTypeCondition() {
		return templateTypeCondition;
	}

	/**
	 * 设置[枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 * 
	 * @param templateTypeCondition [枚举]模板类型：0-优惠券-COUPON、1-悦卡-YUECARD查询条件
	 */
	public void setTemplateTypeCondition(Condition<SpuTemplateType> templateTypeCondition) {
		this.templateTypeCondition = templateTypeCondition;
	}

	/**
	 * 构造并返回[枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 * 
	 * @return publishStatusCondition [枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 */
	public Condition<SpuPublishStatus> publishStatus() {
		this.publishStatusCondition = new Condition<>();
		return this.publishStatusCondition;
	}
	
	/**
	 * 获取[枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 * 
	 * @return publishStatusCondition [枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 */
	public Condition<SpuPublishStatus> getPublishStatusCondition() {
		return publishStatusCondition;
	}

	/**
	 * 设置[枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 * 
	 * @param publishStatusCondition [枚举]上架状态：0-下架-LOWER、1-上架-UPPER查询条件
	 */
	public void setPublishStatusCondition(Condition<SpuPublishStatus> publishStatusCondition) {
		this.publishStatusCondition = publishStatusCondition;
	}

	/**
	 * 构造并返回[枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 * 
	 * @return verifyStatusCondition [枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 */
	public Condition<SpuVerifyStatus> verifyStatus() {
		this.verifyStatusCondition = new Condition<>();
		return this.verifyStatusCondition;
	}
	
	/**
	 * 获取[枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 * 
	 * @return verifyStatusCondition [枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 */
	public Condition<SpuVerifyStatus> getVerifyStatusCondition() {
		return verifyStatusCondition;
	}

	/**
	 * 设置[枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 * 
	 * @param verifyStatusCondition [枚举]审核状态：0-未提交-UNSUBMITTED、1-已提交未审核-CHECKING、2-审核通过-PASSED、3-审核不通过-UNPASSED查询条件
	 */
	public void setVerifyStatusCondition(Condition<SpuVerifyStatus> verifyStatusCondition) {
		this.verifyStatusCondition = verifyStatusCondition;
	}

	/**
	 * 构造并返回[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 */
	public Condition<SpuTimeLimitType> timeLimitType() {
		this.timeLimitTypeCondition = new Condition<>();
		return this.timeLimitTypeCondition;
	}
	
	/**
	 * 获取[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 */
	public Condition<SpuTimeLimitType> getTimeLimitTypeCondition() {
		return timeLimitTypeCondition;
	}

	/**
	 * 设置[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 * 
	 * @param timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS、2-从不失效-NO_RULE查询条件
	 */
	public void setTimeLimitTypeCondition(Condition<SpuTimeLimitType> timeLimitTypeCondition) {
		this.timeLimitTypeCondition = timeLimitTypeCondition;
	}

	/**
	 * 构造并返回失效天数（获取后能够有效的天数）查询条件
	 * 
	 * @return validDaysCondition 失效天数（获取后能够有效的天数）查询条件
	 */
	public Condition<Integer> validDays() {
		this.validDaysCondition = new Condition<>();
		return this.validDaysCondition;
	}
	
	/**
	 * 获取失效天数（获取后能够有效的天数）查询条件
	 * 
	 * @return validDaysCondition 失效天数（获取后能够有效的天数）查询条件
	 */
	public Condition<Integer> getValidDaysCondition() {
		return validDaysCondition;
	}

	/**
	 * 设置失效天数（获取后能够有效的天数）查询条件
	 * 
	 * @param validDaysCondition 失效天数（获取后能够有效的天数）查询条件
	 */
	public void setValidDaysCondition(Condition<Integer> validDaysCondition) {
		this.validDaysCondition = validDaysCondition;
	}

	/**
	 * 构造并返回[枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 * 
	 * @return viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 */
	public Condition<SpuViewModel> viewModel() {
		this.viewModelCondition = new Condition<>();
		return this.viewModelCondition;
	}
	
	/**
	 * 获取[枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 * 
	 * @return viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 */
	public Condition<SpuViewModel> getViewModelCondition() {
		return viewModelCondition;
	}

	/**
	 * 设置[枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 * 
	 * @param viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO、1-运营活动-OPERATION查询条件
	 */
	public void setViewModelCondition(Condition<SpuViewModel> viewModelCondition) {
		this.viewModelCondition = viewModelCondition;
	}

	/**
	 * 构造并返回展示 有效期 开始时间查询条件
	 * 
	 * @return viewBeginTimeCondition 展示 有效期 开始时间查询条件
	 */
	public Condition<LocalDateTime> viewBeginTime() {
		this.viewBeginTimeCondition = new Condition<>();
		return this.viewBeginTimeCondition;
	}
	
	/**
	 * 获取展示 有效期 开始时间查询条件
	 * 
	 * @return viewBeginTimeCondition 展示 有效期 开始时间查询条件
	 */
	public Condition<LocalDateTime> getViewBeginTimeCondition() {
		return viewBeginTimeCondition;
	}

	/**
	 * 设置展示 有效期 开始时间查询条件
	 * 
	 * @param viewBeginTimeCondition 展示 有效期 开始时间查询条件
	 */
	public void setViewBeginTimeCondition(Condition<LocalDateTime> viewBeginTimeCondition) {
		this.viewBeginTimeCondition = viewBeginTimeCondition;
	}

	/**
	 * 构造并返回展示 有效期 结束时间查询条件
	 * 
	 * @return viewEndTimeCondition 展示 有效期 结束时间查询条件
	 */
	public Condition<LocalDateTime> viewEndTime() {
		this.viewEndTimeCondition = new Condition<>();
		return this.viewEndTimeCondition;
	}
	
	/**
	 * 获取展示 有效期 结束时间查询条件
	 * 
	 * @return viewEndTimeCondition 展示 有效期 结束时间查询条件
	 */
	public Condition<LocalDateTime> getViewEndTimeCondition() {
		return viewEndTimeCondition;
	}

	/**
	 * 设置展示 有效期 结束时间查询条件
	 * 
	 * @param viewEndTimeCondition 展示 有效期 结束时间查询条件
	 */
	public void setViewEndTimeCondition(Condition<LocalDateTime> viewEndTimeCondition) {
		this.viewEndTimeCondition = viewEndTimeCondition;
	}

	/**
	 * 构造并返回购买开始时间查询条件
	 * 
	 * @return buyBeginTimeCondition 购买开始时间查询条件
	 */
	public Condition<LocalDateTime> buyBeginTime() {
		this.buyBeginTimeCondition = new Condition<>();
		return this.buyBeginTimeCondition;
	}
	
	/**
	 * 获取购买开始时间查询条件
	 * 
	 * @return buyBeginTimeCondition 购买开始时间查询条件
	 */
	public Condition<LocalDateTime> getBuyBeginTimeCondition() {
		return buyBeginTimeCondition;
	}

	/**
	 * 设置购买开始时间查询条件
	 * 
	 * @param buyBeginTimeCondition 购买开始时间查询条件
	 */
	public void setBuyBeginTimeCondition(Condition<LocalDateTime> buyBeginTimeCondition) {
		this.buyBeginTimeCondition = buyBeginTimeCondition;
	}

	/**
	 * 构造并返回购买结束时间查询条件
	 * 
	 * @return buyEndTimeCondition 购买结束时间查询条件
	 */
	public Condition<LocalDateTime> buyEndTime() {
		this.buyEndTimeCondition = new Condition<>();
		return this.buyEndTimeCondition;
	}
	
	/**
	 * 获取购买结束时间查询条件
	 * 
	 * @return buyEndTimeCondition 购买结束时间查询条件
	 */
	public Condition<LocalDateTime> getBuyEndTimeCondition() {
		return buyEndTimeCondition;
	}

	/**
	 * 设置购买结束时间查询条件
	 * 
	 * @param buyEndTimeCondition 购买结束时间查询条件
	 */
	public void setBuyEndTimeCondition(Condition<LocalDateTime> buyEndTimeCondition) {
		this.buyEndTimeCondition = buyEndTimeCondition;
	}

	/**
	 * 构造并返回有效期 开始时间查询条件
	 * 
	 * @return beginTimeCondition 有效期 开始时间查询条件
	 */
	public Condition<LocalDateTime> beginTime() {
		this.beginTimeCondition = new Condition<>();
		return this.beginTimeCondition;
	}
	
	/**
	 * 获取有效期 开始时间查询条件
	 * 
	 * @return beginTimeCondition 有效期 开始时间查询条件
	 */
	public Condition<LocalDateTime> getBeginTimeCondition() {
		return beginTimeCondition;
	}

	/**
	 * 设置有效期 开始时间查询条件
	 * 
	 * @param beginTimeCondition 有效期 开始时间查询条件
	 */
	public void setBeginTimeCondition(Condition<LocalDateTime> beginTimeCondition) {
		this.beginTimeCondition = beginTimeCondition;
	}

	/**
	 * 构造并返回有效期 结束时间查询条件
	 * 
	 * @return endTimeCondition 有效期 结束时间查询条件
	 */
	public Condition<LocalDateTime> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}
	
	/**
	 * 获取有效期 结束时间查询条件
	 * 
	 * @return endTimeCondition 有效期 结束时间查询条件
	 */
	public Condition<LocalDateTime> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置有效期 结束时间查询条件
	 * 
	 * @param endTimeCondition 有效期 结束时间查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDateTime> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回商品描述 图片列表查询条件
	 * 
	 * @return descriptionCondition 商品描述 图片列表查询条件
	 */
	public Condition<String> description() {
		this.descriptionCondition = new Condition<>();
		return this.descriptionCondition;
	}
	
	/**
	 * 获取商品描述 图片列表查询条件
	 * 
	 * @return descriptionCondition 商品描述 图片列表查询条件
	 */
	public Condition<String> getDescriptionCondition() {
		return descriptionCondition;
	}

	/**
	 * 设置商品描述 图片列表查询条件
	 * 
	 * @param descriptionCondition 商品描述 图片列表查询条件
	 */
	public void setDescriptionCondition(Condition<String> descriptionCondition) {
		this.descriptionCondition = descriptionCondition;
	}

	/**
	 * 构造并返回商品图片描述 图片列表查询条件
	 * 
	 * @return imgDescriptionCondition 商品图片描述 图片列表查询条件
	 */
	public Condition<String> imgDescription() {
		this.imgDescriptionCondition = new Condition<>();
		return this.imgDescriptionCondition;
	}
	
	/**
	 * 获取商品图片描述 图片列表查询条件
	 * 
	 * @return imgDescriptionCondition 商品图片描述 图片列表查询条件
	 */
	public Condition<String> getImgDescriptionCondition() {
		return imgDescriptionCondition;
	}

	/**
	 * 设置商品图片描述 图片列表查询条件
	 * 
	 * @param imgDescriptionCondition 商品图片描述 图片列表查询条件
	 */
	public void setImgDescriptionCondition(Condition<String> imgDescriptionCondition) {
		this.imgDescriptionCondition = imgDescriptionCondition;
	}

	/**
	 * 构造并返回[枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 * 
	 * @return packageTypeCondition [枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 */
	public Condition<SpuPackageType> packageType() {
		this.packageTypeCondition = new Condition<>();
		return this.packageTypeCondition;
	}
	
	/**
	 * 获取[枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 * 
	 * @return packageTypeCondition [枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 */
	public Condition<SpuPackageType> getPackageTypeCondition() {
		return packageTypeCondition;
	}

	/**
	 * 设置[枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 * 
	 * @param packageTypeCondition [枚举]是否套餐：0-否-NO、1-是-YES查询条件
	 */
	public void setPackageTypeCondition(Condition<SpuPackageType> packageTypeCondition) {
		this.packageTypeCondition = packageTypeCondition;
	}

	/**
	 * 构造并返回浏览量查询条件
	 * 
	 * @return scanNumCondition 浏览量查询条件
	 */
	public Condition<Integer> scanNum() {
		this.scanNumCondition = new Condition<>();
		return this.scanNumCondition;
	}
	
	/**
	 * 获取浏览量查询条件
	 * 
	 * @return scanNumCondition 浏览量查询条件
	 */
	public Condition<Integer> getScanNumCondition() {
		return scanNumCondition;
	}

	/**
	 * 设置浏览量查询条件
	 * 
	 * @param scanNumCondition 浏览量查询条件
	 */
	public void setScanNumCondition(Condition<Integer> scanNumCondition) {
		this.scanNumCondition = scanNumCondition;
	}

	/**
	 * 构造并返回使用规则查询条件
	 * 
	 * @return useRuleCondition 使用规则查询条件
	 */
	public Condition<String> useRule() {
		this.useRuleCondition = new Condition<>();
		return this.useRuleCondition;
	}
	
	/**
	 * 获取使用规则查询条件
	 * 
	 * @return useRuleCondition 使用规则查询条件
	 */
	public Condition<String> getUseRuleCondition() {
		return useRuleCondition;
	}

	/**
	 * 设置使用规则查询条件
	 * 
	 * @param useRuleCondition 使用规则查询条件
	 */
	public void setUseRuleCondition(Condition<String> useRuleCondition) {
		this.useRuleCondition = useRuleCondition;
	}

	/**
	 * 构造并返回创建人ID查询条件
	 * 
	 * @return createdByCondition 创建人ID查询条件
	 */
	public Condition<String> createdBy() {
		this.createdByCondition = new Condition<>();
		return this.createdByCondition;
	}
	
	/**
	 * 获取创建人ID查询条件
	 * 
	 * @return createdByCondition 创建人ID查询条件
	 */
	public Condition<String> getCreatedByCondition() {
		return createdByCondition;
	}

	/**
	 * 设置创建人ID查询条件
	 * 
	 * @param createdByCondition 创建人ID查询条件
	 */
	public void setCreatedByCondition(Condition<String> createdByCondition) {
		this.createdByCondition = createdByCondition;
	}

	/**
	 * 构造并返回创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}
	
	/**
	 * 获取创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置创建时间查询条件
	 * 
	 * @param createdTimeCondition 创建时间查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回更新人ID查询条件
	 * 
	 * @return modifiedByCondition 更新人ID查询条件
	 */
	public Condition<String> modifiedBy() {
		this.modifiedByCondition = new Condition<>();
		return this.modifiedByCondition;
	}
	
	/**
	 * 获取更新人ID查询条件
	 * 
	 * @return modifiedByCondition 更新人ID查询条件
	 */
	public Condition<String> getModifiedByCondition() {
		return modifiedByCondition;
	}

	/**
	 * 设置更新人ID查询条件
	 * 
	 * @param modifiedByCondition 更新人ID查询条件
	 */
	public void setModifiedByCondition(Condition<String> modifiedByCondition) {
		this.modifiedByCondition = modifiedByCondition;
	}

	/**
	 * 构造并返回更新时间查询条件
	 * 
	 * @return modifiedTimeCondition 更新时间查询条件
	 */
	public Condition<LocalDateTime> modifiedTime() {
		this.modifiedTimeCondition = new Condition<>();
		return this.modifiedTimeCondition;
	}
	
	/**
	 * 获取更新时间查询条件
	 * 
	 * @return modifiedTimeCondition 更新时间查询条件
	 */
	public Condition<LocalDateTime> getModifiedTimeCondition() {
		return modifiedTimeCondition;
	}

	/**
	 * 设置更新时间查询条件
	 * 
	 * @param modifiedTimeCondition 更新时间查询条件
	 */
	public void setModifiedTimeCondition(Condition<LocalDateTime> modifiedTimeCondition) {
		this.modifiedTimeCondition = modifiedTimeCondition;
	}

	/**
	 * 构造并返回审批人查询条件
	 * 
	 * @return checkByCondition 审批人查询条件
	 */
	public Condition<String> checkBy() {
		this.checkByCondition = new Condition<>();
		return this.checkByCondition;
	}
	
	/**
	 * 获取审批人查询条件
	 * 
	 * @return checkByCondition 审批人查询条件
	 */
	public Condition<String> getCheckByCondition() {
		return checkByCondition;
	}

	/**
	 * 设置审批人查询条件
	 * 
	 * @param checkByCondition 审批人查询条件
	 */
	public void setCheckByCondition(Condition<String> checkByCondition) {
		this.checkByCondition = checkByCondition;
	}

	/**
	 * 构造并返回审批时间查询条件
	 * 
	 * @return checkTimeCondition 审批时间查询条件
	 */
	public Condition<LocalDateTime> checkTime() {
		this.checkTimeCondition = new Condition<>();
		return this.checkTimeCondition;
	}
	
	/**
	 * 获取审批时间查询条件
	 * 
	 * @return checkTimeCondition 审批时间查询条件
	 */
	public Condition<LocalDateTime> getCheckTimeCondition() {
		return checkTimeCondition;
	}

	/**
	 * 设置审批时间查询条件
	 * 
	 * @param checkTimeCondition 审批时间查询条件
	 */
	public void setCheckTimeCondition(Condition<LocalDateTime> checkTimeCondition) {
		this.checkTimeCondition = checkTimeCondition;
	}

	/**
	 * 构造并返回审批意见查询条件
	 * 
	 * @return checkRemarkCondition 审批意见查询条件
	 */
	public Condition<String> checkRemark() {
		this.checkRemarkCondition = new Condition<>();
		return this.checkRemarkCondition;
	}
	
	/**
	 * 获取审批意见查询条件
	 * 
	 * @return checkRemarkCondition 审批意见查询条件
	 */
	public Condition<String> getCheckRemarkCondition() {
		return checkRemarkCondition;
	}

	/**
	 * 设置审批意见查询条件
	 * 
	 * @param checkRemarkCondition 审批意见查询条件
	 */
	public void setCheckRemarkCondition(Condition<String> checkRemarkCondition) {
		this.checkRemarkCondition = checkRemarkCondition;
	}

	/**
	 * 构造并返回逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> del() {
		this.delCondition = new Condition<>();
		return this.delCondition;
	}
	
	/**
	 * 获取逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> getDelCondition() {
		return delCondition;
	}

	/**
	 * 设置逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @param delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public void setDelCondition(Condition<Boolean> delCondition) {
		this.delCondition = delCondition;
	}

	/**
	 * 构造并返回删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> delBy() {
		this.delByCondition = new Condition<>();
		return this.delByCondition;
	}
	
	/**
	 * 获取删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> getDelByCondition() {
		return delByCondition;
	}

	/**
	 * 设置删除人ID查询条件
	 * 
	 * @param delByCondition 删除人ID查询条件
	 */
	public void setDelByCondition(Condition<String> delByCondition) {
		this.delByCondition = delByCondition;
	}

	/**
	 * 构造并返回删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> delTime() {
		this.delTimeCondition = new Condition<>();
		return this.delTimeCondition;
	}
	
	/**
	 * 获取删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> getDelTimeCondition() {
		return delTimeCondition;
	}

	/**
	 * 设置删除时间查询条件
	 * 
	 * @param delTimeCondition 删除时间查询条件
	 */
	public void setDelTimeCondition(Condition<LocalDateTime> delTimeCondition) {
		this.delTimeCondition = delTimeCondition;
	}

	/**
	 * 构造并返回排序查询条件
	 * 
	 * @return sortNoCondition 排序查询条件
	 */
	public Condition<Integer> sortNo() {
		this.sortNoCondition = new Condition<>();
		return this.sortNoCondition;
	}
	
	/**
	 * 获取排序查询条件
	 * 
	 * @return sortNoCondition 排序查询条件
	 */
	public Condition<Integer> getSortNoCondition() {
		return sortNoCondition;
	}

	/**
	 * 设置排序查询条件
	 * 
	 * @param sortNoCondition 排序查询条件
	 */
	public void setSortNoCondition(Condition<Integer> sortNoCondition) {
		this.sortNoCondition = sortNoCondition;
	}

	/**
	 * 构造并返回售卖开始时间查询条件
	 * 
	 * @return sellBeginTimeCondition 售卖开始时间查询条件
	 */
	public Condition<LocalDateTime> sellBeginTime() {
		this.sellBeginTimeCondition = new Condition<>();
		return this.sellBeginTimeCondition;
	}
	
	/**
	 * 获取售卖开始时间查询条件
	 * 
	 * @return sellBeginTimeCondition 售卖开始时间查询条件
	 */
	public Condition<LocalDateTime> getSellBeginTimeCondition() {
		return sellBeginTimeCondition;
	}

	/**
	 * 设置售卖开始时间查询条件
	 * 
	 * @param sellBeginTimeCondition 售卖开始时间查询条件
	 */
	public void setSellBeginTimeCondition(Condition<LocalDateTime> sellBeginTimeCondition) {
		this.sellBeginTimeCondition = sellBeginTimeCondition;
	}

	/**
	 * 构造并返回售卖结束时间查询条件
	 * 
	 * @return sellEndTimeCondition 售卖结束时间查询条件
	 */
	public Condition<LocalDateTime> sellEndTime() {
		this.sellEndTimeCondition = new Condition<>();
		return this.sellEndTimeCondition;
	}
	
	/**
	 * 获取售卖结束时间查询条件
	 * 
	 * @return sellEndTimeCondition 售卖结束时间查询条件
	 */
	public Condition<LocalDateTime> getSellEndTimeCondition() {
		return sellEndTimeCondition;
	}

	/**
	 * 设置售卖结束时间查询条件
	 * 
	 * @param sellEndTimeCondition 售卖结束时间查询条件
	 */
	public void setSellEndTimeCondition(Condition<LocalDateTime> sellEndTimeCondition) {
		this.sellEndTimeCondition = sellEndTimeCondition;
	}

	/**
	 * 构造并返回倒计时开始时间查询条件
	 * 
	 * @return invertedBeginTimeCondition 倒计时开始时间查询条件
	 */
	public Condition<LocalDateTime> invertedBeginTime() {
		this.invertedBeginTimeCondition = new Condition<>();
		return this.invertedBeginTimeCondition;
	}
	
	/**
	 * 获取倒计时开始时间查询条件
	 * 
	 * @return invertedBeginTimeCondition 倒计时开始时间查询条件
	 */
	public Condition<LocalDateTime> getInvertedBeginTimeCondition() {
		return invertedBeginTimeCondition;
	}

	/**
	 * 设置倒计时开始时间查询条件
	 * 
	 * @param invertedBeginTimeCondition 倒计时开始时间查询条件
	 */
	public void setInvertedBeginTimeCondition(Condition<LocalDateTime> invertedBeginTimeCondition) {
		this.invertedBeginTimeCondition = invertedBeginTimeCondition;
	}

	/**
	 * 构造并返回倒计时结束时间查询条件
	 * 
	 * @return invertedEndTimeCondition 倒计时结束时间查询条件
	 */
	public Condition<LocalDateTime> invertedEndTime() {
		this.invertedEndTimeCondition = new Condition<>();
		return this.invertedEndTimeCondition;
	}
	
	/**
	 * 获取倒计时结束时间查询条件
	 * 
	 * @return invertedEndTimeCondition 倒计时结束时间查询条件
	 */
	public Condition<LocalDateTime> getInvertedEndTimeCondition() {
		return invertedEndTimeCondition;
	}

	/**
	 * 设置倒计时结束时间查询条件
	 * 
	 * @param invertedEndTimeCondition 倒计时结束时间查询条件
	 */
	public void setInvertedEndTimeCondition(Condition<LocalDateTime> invertedEndTimeCondition) {
		this.invertedEndTimeCondition = invertedEndTimeCondition;
	}

	/**
	 * 构造并返回[枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 * 
	 * @return invertedShowCondition [枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 */
	public Condition<Integer> invertedShow() {
		this.invertedShowCondition = new Condition<>();
		return this.invertedShowCondition;
	}
	
	/**
	 * 获取[枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 * 
	 * @return invertedShowCondition [枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 */
	public Condition<Integer> getInvertedShowCondition() {
		return invertedShowCondition;
	}

	/**
	 * 设置[枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 * 
	 * @param invertedShowCondition [枚举]是否显示倒计时：0-不显示-HIDE、1-显示-SHOW查询条件
	 */
	public void setInvertedShowCondition(Condition<Integer> invertedShowCondition) {
		this.invertedShowCondition = invertedShowCondition;
	}

}
